Synthèse et édition d'images de visage par réseaux génératifs

Letzelter Victor et Herpin Loïc

Sujet :

La synthèse d'images a ces dernières années connus des progrès spectaculaires grâce à des approches par réseaux profonds génératifs. En particulier, un réseau adversarial génératif (GAN) particulièrement efficace a été proposé dans ce papier,[1] puis amélioré dans celui-ci [2] pour la synthèse de visages. Cette architecture permet la représentation des visages dans un espace dit espace latent. Le but du projet est d'explorer les possibilités d'édition offertes par cet espace latent, par exemple en s'inspirant de l'approche proposée dans ce papier [3].

Bibliographie :

[1] Karras, Tero, Samuli Laine, and Timo Aila. "A style-based generator architecture for generative adversarial networks." arXiv preprint arXiv:1812.04948 (2018).

[2] Karras, Tero, et al. "Analyzing and improving the image quality of stylegan." Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 2020.

[3] Shen, Yujun, et al. "Interfacegan: Interpreting the disentangled face representation learned by gans." IEEE transactions on pattern analysis and machine intelligence (2020).

[4] Goodfellow, Ian, et al. "Generative adversarial nets." Advances in neural information processing systems 27 (2014).

[5] Zhu, Jiapeng, et al. "In-domain gan inversion for real image editing." European conference on computer vision. Springer, Cham, 2020.

[6] Xia, Weihao, et al. "GAN inversion: A survey." arXiv preprint arXiv:2101.05278 (2021).

[7] Borji, Ali. "Pros and cons of GAN evaluation measures: New developments." Computer Vision and Image Understanding 215 (2022): 103329.

[8] Zhu, Jun-Yan, et al. "Generative visual manipulation on the natural image manifold." European conference on computer vision. Springer, Cham, 2016.

[9] Härkönen, Erik, et al. "Ganspace: Discovering interpretable gan controls." Advances in Neural Information Processing Systems 33 (2020): 9841-9850.

Repo utilisés :

[*] https://github.com/genforce/interfacegan

[*] https://github.com/NVlabs/stylegan2-ada-pytorch

[*] https://github.com/genforce/idinvert.git

Initialisation du notebook

Imports

Présentation du sujet

Sommaire :

1. La synthèse d'image par réseau profond génératif

1.1 Réseau Adversarial Génératif (GAN)

Les GANs designent une classe de réseau génératif d'images fonctionnant de manière non supervisée introduits par Goodfellow et al. en 2014$^{[4]}$. Leur design consiste en l'opposition de deux réseaux : le générateur $G$ et le discriminateur $D$. Le premier apprend à mapper un espace latent ($\mathcal{Z} \subseteq \mathbb{R}^d$) à une distribution ($\mathcal{X}$), le second cherche à discriminer la distribution réelle et les données générées. L'entraînement de $G$ et $D$ et réalisé via l'optimisation Two-players minmax game

$$ \min _{G} \max _{D} V(D, G) =\mathbb{E}_{\mathbf{x} \sim p_{\text {data }}(\mathbf{x})}[\log D(\mathbf{x})]+\mathbb{E}_{\mathbf{z} \sim p_{\mathbf{z}}(\mathbf{z})}[\log (1-D(G(\mathbf{z})))] $$

où $p_{\text {data}}$ et $p_{\mathbf{z}}$ correspondent respectivement à la distribution et donnée réelles et des données simulées.

Une architecture usuelle pour le générateur consiste à partir d'un vecteur $z \sim \mathcal{N}(0,I_d)$ et de le transmettre au travers d'un réseau déconvolutif (pour créer une image de taille 4x4, 8x8, etc.).

1.2 StyleGAN

Le modèle utilisé dans notre travail est celui introduit par Karras et al.[1] en 2018 : StyleGAN.

Ce modèle dévie des GANs habituels de par le contrôle sur l'output qu'il apporte. Usuellement, le générateur a pour architecture un réseau déconvolutif (fig. 1a) : un vecteur $\mathbf{z} \in \mathcal{Z}$ passe à travers un mapping $G : \mathcal{Z} \to \mathcal{X}$.

L'architecture de StyleGAN décompose ce mapping en deux mapping $G_1 : \mathcal{Z} \to \mathcal{W}$ et $G_2 : \mathcal{W} \to \mathcal{X}$. En introduisant un espace intermédiaire $\mathcal{W}$, StyleGAN permet ainsi l'accès à un espace qui est plus désenchevêtré que l'espace latent initial $\mathcal{Z}$, et en conséquence un contrôle plus fin des attributs de l'image de sortie.

De plus, l'architecture de StyleGAN diffère aussi de par la façon dont le vecteur $\mathbf{w} \in \mathcal{W}$ est transmis au réseau déconvolutif (fig. 1b). Le vecteur $\mathbf{w}$ est ainsi transmis indépendemment à chaque étape de déconvolution du générateur au travers de l'opération AdaIN (adaptive instance normalization) définie par :

$$ \text{AdaIN}(x_i,y) = y_{s,i}\frac{x_i - \mu(x_i)}{\sigma(x_i)} + y_{b,i} $$

Où $x_i$ sont les features maps et y = ($y_s$, $y_b$) sont obtenus par une transformation affine sur $\mathbf{w}$

Cette manière de transmettre indépendemment à chacunes des 18 étapes de déconvolution $\mathbf{w}$ permet alors de pouvoir fournir des vecteurs $\mathbf{w}$ différents pour chaque étape. Il faut noter par ailleurs que chaque étape contrôle un degré différent de détail : les premiers niveaux impacteront des caractéristiques plus grossières (genre, pose, etc.) et les derniers niveaux impacteront des caractéristiques plus fines (couleur de cheveux, tâches de rousseur, etc.). Ainsi une des innovations apportée par StyleGAN est le transfert de style d'une image à une autre. Au cours de la construction de l'image du générateur, on peut ainsi fournir pour les dernières étapes de déconvolution le vecteur $\mathbf{w}_{2}$ de la seconde image au lieu du vecteur $\mathbf{w}_{1}$ de la première et ainsi récupérer ses caractéristiques fines.

Figure 1: Extrait de l'article par Karras et al.[1]

2. Inversion d'une image réelle

2.1 . Etat de l'art en inversion de GANs

La performance des GANs pour la génération d'images synthétiques étant bien reconnue, le domaine de recherche de la manipulation d'images réelle avec les GANs, connu sous le nom d'inversion de GANs, a émergé au cours des dernières années. Cette inversion de GANs est motivée, entre autres, par la possibilité d'effectuer des manipulations réelles d'images en agissant sur l'espace latent sur lequel le Gerarateur $G$ est défini.

L'objectif de cette section est de décrire formellement l'état de l'art des méthodes d'inversion de GANs, et d'explorer les possibilités qu'elle offre en matière de manipulation d'images et de modification d'attributs dans le domaine de la génération de visages.

Description formelle du problème

Considérons un GAN composé d'un générateur $G : \mathcal{Z} \rightarrow \mathcal{X}$ et d'un discriminateur $D : \mathcal{X} \rightarrow [0,1]$. Le but du problème d'inversion du GAN est, étant donné une image réelle $\mathbf{x} \in \mathcal{X}$, de retrouver un code latent $\mathbf{z} \in \mathcal{Z}$ tel que $G(\mathbf{z})=\mathbf{x}$. En pratique, on cherchera $\tilde{\mathbf{z}}$ telle que la distance $d$ entre $G(\tilde{\mathbf{z}})$ et $\mathbf{x}$ soit la plus petite possible. Le problème d'optimisation peut donc s'écrire comme suit

\begin{equation} \tag{1} \mathbf{z^{*}} = \underset{\mathbf{z} \in \mathcal{Z}}{\mathrm{argmin}} \; d(G(\mathbf{z}),\mathbf{x}) \end{equation}

La métrique de distance $d$ peut être choisie pour être une distance perceptive, qui peut typiquement être mesurée en utilisant un CNN feed-forward pré-entraîné $F$ (par exemple VGG entraîné sur Image-Net, [5,6]), qui met en correspondance une image d'entrée avec une distribution de classes : $$d : \left\{\begin{array}{l} \mathcal{X} \times \mathcal{X} \longrightarrow \mathbb{R}_{+} \\ (\mathbf{x}, \mathbf{y}) \mapsto \|F(\mathbf{x})-F(\mathbf{y})\|_{2} \end{array}\right.$$

Il existe deux approches générales pour résoudre le problème d'optimisation (1) : l'approche basée sur l'optimisation (Optimization based GAN inversion) et l'approche basée sur l'entraînement d'un encoder (Learning based approach).

L'inversion GAN basée sur l'optimisation consiste à résoudre (1) en utilisant un générateur pré-entraîné avec des poids fixes $\theta$ : $$\mathbf{z}^{*}=\underset{\mathbf{z} \in \mathcal{Z}}{\mathrm{argmin}} \;d(\mathbf{x}, G_{\theta}(\mathbf{z}))$$ Dans ce cas, les méthodes de descente de gradient peuvent être appliquées, étant donné le code latent initial $\mathbf{z}_{0}$ comme point de départ. Comme (1) n'est généralement pas convexe, le point de départ a une grande importance et un mauvais choix peut bloquer l'optimiseur (par exemple Adam, SGD) dans un minima local. Une approche possible pour traiter ce type de problème, proposée dans [1], est s'intitulant truncation trick consistant à calculer le centre de masse dans l'espace latent considéré (par exemple dans $\mathcal{W}$: $\overline{\mathbf{w}}=\mathbb{E}_{\mathbf{z} \sim P(\mathbf{z})}[f(\mathbf{z})]$, par MC sampling par exemple), puis, pour un $\mathbf{w}$ échantilonné dans l'espace $\mathcal{W}$, appliquer la transformation: $$\tau_{\psi}: \mathbf{w} \mapsto \overline{\mathbf{w}}+\psi(\mathbf{w}-\overline{\mathbf{w}}) $$ où $\psi \in [-1,1]$.

L'approche basée sur l'apprentissage consiste à entraîner un encodeur $E$ pour mapper un code latent $\mathbf{z} \in \mathcal{Z}$ étant donné une image $\mathbf{x}$. Si l'on considère un ensemble de $N$ exemples $\{(\mathbf{x}_{n}, \mathbf{z}_{n})\}_{n \in [\![1,N]\!]}$, les paramètres du réseau de l'encodeur peuvent être ajustés en résolvant le problème d'optimisation suivant :

\begin{equation} \tag{2} \theta_{E}^{*}=\underset{\theta_{E}}{\arg \min } \sum_{n} \ell \left(G\left(E_{\theta_{E}}\left(\mathbf{x}_{n}\right)\right), \mathbf{x}_{n}\right) \end{equation}

Où $\ell$ est une fonction de perte appropriée. Cette formulation a été proposée par Zhu et al. [5] comme une alternative à la reconstruction dans l'espace $\mathcal{Z}$ : \begin{equation} \tag{3} \theta_{E}^{*}=\underset{\theta_{E}}{\arg \min } \sum_{n} \ell'\left(E_{\theta_{E}}\left(\mathbf{x}_{n}\right), \mathbf{z}_{n}\right) \end{equation} car (3) omet le $G$ dans le processus d'optimisation et donc la connaissance du domaine du générateur. Une fois entraînée, l'approche basée sur l'apprentissage est donc déterministe puisque $E$ devient une fonction déterministe.

La méthode basée sur l'optimisation permet généralement d'obtenir une meilleure reconstruction de la sémantique du visage par rapport aux méthodes basées sur l'encodage pour un code latent initial bien choisi $\mathbf{z}_{0} \in \mathcal{Z}$ mais la méthode basée sur l'encodeur est plus rapide à réaliser [3,6]. C'est pourquoi des méthodes hybrides ont été proposées, afin de tirer profit à la fois des méthodes basées sur l'optimisation et sur l'apprentissage. L'idée initiale de ces méthodes hybrides, proposée par Zhu et al. dans [8], consiste à utiliser à la fois l'encodeur $E_{\theta_{E}}$ et l'optimiseur à code latent de telle sorte que, pour une image d'entrée $\mathbf{x}$, le point $\mathbf{z}_{0}=E_{\theta_{E}}(\mathbf{x})$ est choisi comme point de départ de l'optimisation.

De façon plus spécifique la méthode hybride proposée par Zhu et al. dans [5] - In-domain-GAN repose sur le processus d'optimisation suivant:

D'une part, l'encoder est optisée en résolvant le problème d'optimisation suivant: Tout d'abord, l'encoder est entraîné de façon supervisé en se basant sur les exemples d'entraînement sous la forme $\{ (\mathbf{x}_{i},\mathbf{w}_{n})\}_{n \in [\![1,N]\!]} \in (\mathcal{X} \times \mathcal{Z})^{N}$ $$ \theta_{E} = \underset{\theta_{E}}{\mathrm{argmin}} \sum_{n} \lambda_{1} \underbrace{\left\|E_{\theta_{E}}(\mathbf{x}_{n})-\mathbf{w}_{n} \right\|_{2}}_{\text {latent loss }}+\lambda_{2} \underbrace{\left\|G(E_{\theta_{E}}(\mathbf{x}_{n}))-\mathbf{x}_{n}\right\|_{2}}_{\text {image reconstruction loss }}+\lambda_{3} \underbrace{d\left(G(E_{\theta_{E}}(\mathbf{x}_{n})), \mathbf{x}_{n}\right)}_{\text {perceptual feature loss }} $$

où $\lambda_{1},\lambda_{2},\lambda_{3} \in \mathbb{R}_{+}$ ont été déterminés dans [5], $G:=G_{\theta_{G}} : \mathcal{Z} \rightarrow \mathcal{X}$ est préentrainé et fixe, et $d$ est une distance perceptuelle calculée en utilisant, par exemple, un VGG noté $F$ (voir plus haut), et $E_{\theta_{E}} : \mathcal{X} \rightarrow \mathcal{Z}$.

Par la suite, le problème d'optisation dans l'espace latent $\mathcal{Z}$ pour $\mathbf{x} \in \mathcal{X}$ donné est:

$$ \mathbf{w}^{*} = \underset{\mathbf{w}}{\mathrm{argmin}}\; \|G(\mathbf{w})-\mathbf{x}\|_{2}+\alpha d(G(\mathbf{w}), \mathbf{x})+\beta \|\mathbf{w}-E(G(\mathbf{w}))\|_{2} $$

où $\alpha >0$ est un paramètre ajustable.

Dans le cadre de StyleGAN, le générateur est composé de deux réseaux de feed-forward, le réseau de mapping $G_{1} : \mathcal{Z} \rightarrow \mathcal{W}$, et le réseau de synthèse $G_{2} : \mathcal{W} \rightarrow \mathcal{X}$ tel que : $G = G_{2} \circ G_{1}$. Il a été démontré par des études de désenchevêtrement [1,2,3] que l'espace latent $\mathcal{W}$ est plus adapté pour manipuler les attributs des images générées de manière indépendante, i.e : les frontières séparant les attribus sont modélisables par des hyperplans avec une bonne approximation. Pour ce faire, des métriques ont été conçues à partir de la mesure du désenchevêtrement (notamment Perceptual Path Length et Linear Separability, voir [1,7]).

Dans ce contexte, le problème d'optimisation peut être reformulé comme suit

$$\mathbf{w^{*}} = \underset{\mathbf{w} \in \mathcal{W}}{\mathrm{argmin}} \; d(G_{2}(\mathbf{w}),\mathbf{x})$$

Typiquement, les réseaux StyleGAN peuvent être conçus de telle sorte que $\mathrm{dim}(\mathcal{X})=256 \times 256$ et $\mathrm{dim}(\mathcal{W})=\mathrm{dim}(\mathcal{Z})=512$ (Architecture utilisée dans l'expérience). Comme l'échantillonnage direct à partir de $\mathcal{W}$ ou $\mathcal{Z}$ peut être délicat [6] en raison de la différence de dimensions, une alternative consiste à considérer un autre espace latent, appelé $\mathcal{W}^{+}$, de dimension $\mathrm{dim}(\mathcal{Z})=512 \times N_{layers}$, où $N_{layers}$ est le nombre de couches du réseau de synthèse $G_{2}$. Dans ce cadre, pour $\mathbf{w}^{+} \in \mathbb{R}^{512 \times N_{layers}}$ vu comme une matrice, chaque colonne $\mathbf{w}^{+}_{.,j}$ correspond à un vecteur alimentant le bloc de style convolutionnel numéro $\lfloor \frac{j+1}{2} \rfloor$ de StyleGAN via l'AdaIN (Adaptive Instance Normalisation) ; le réseau $G_{2}$ possède deux AdaIN par bloc.

Une fois le code latent $\mathbf{w}^{+}$ d'une image $\mathbf{x}$ a été obtenu, la modification d'une image dans la direction d'un attribut associé à un hyperplan de vecteur normal $\mathbf{n} \in \mathcal{W}^{+}$ est réalisé en calculant, $\{ G_{2}(\mathbf{w}^{+}+\lambda \mathbf{n}$), $\lambda \in [\![-a,a]\!]$ }, où $a \in \mathbb{N}$ permet de fixer la distance à laquelle on s'eloigne de la frontière associée à l'attribut correspondant.

2.2 . Importation du code

ID GAN inversion Git : https://github.com/Victorletzelter/idinvert_pytorch.git

2.3 Expériences réalisées sur des images réelles

Les expériences qui suivent ont été réalisé à partir d'un StyleGAN - 256x256 entraîné sur le dataset FFHQ (Flicker Faces High Quality).

Cette section consiste en une étude qualitative des performances de différents GANs inverters et dans différentes configurations.

Considérons l'image suivante, qu'il s'agira d'inverser puis de manipuler.

Réalisons les réglages du modèle qui sera utilisé dans toute la suite.

2.3.1 Impact de l'initialisation

Considérons dans un premier temps l'inversion d'une image réelle dans $\mathcal{W}^{+}$, en utilisant une méthode Optimisation based, et étudions l'influence du point de départ $\mathbf{w}_{0}$ sur le résultat.

Commençons par réaliser des prétraitements sur l'image.

Définissons la fonction d'optimisation du code latent $\mathbf{w}$.

Dans le cas optimal, les l'image obtenue après 300 itérations d'optimisation est la suivante.

Sauvegardons le code latent obtenu

Dans le cas 0 (naïf), on note que l'image produite est bien moins rationnelle d'un point de vue sémantique.

Dans le cas 1 (ci-dessous), la reconstruction est de meilleure qualité, mais reste très dépendante de l'image de départ.

Enfin, dans le troisième cas, l'image obtenue est relativement satisfaisante. La qualité de la reconstruction est classée seconde après celle du Cas optimal.

De façon plus quantitative, il est possible de comparer les valeurs des Loss obtenues dans les trois cas

On remarque que les méthodes correspondants aux cas 0 à 3 s'échelonnent bien de la méthode la moins à la plus compétitive.

3. Manipulation d'image

Comme évoqué précédemment, l'espace latent $\mathcal{W}$ est relativement désenchevêtré et l'on peut modéliser les frontières entre les attributs par des hyperplans. Une manière d'observer cela est d'interpoler deux images $w_1$ et $w_2$ et d'observer une modification continue des attributs des deux images.

Par ailleurs, StyleGAN offre la possibilité de transférer le style d'une image vers une autre en modifiant les vecteurs $w$ transmis aux différentes étapes de déconvolution. On peut alors extrapoler qu'en identifiant les hyperplans associés à différents attributs spécifiques, l'on pourrait directement modifier une image sans besoin d'une seconde.

Plusieurs manières ont été avancées dans la littérature pour identifier ces hyperplans : par apprentissage supervisé de ces hyperplans (comme InterFaceGAN introduit par Shen et al.[3]), par entraînement de GAN sur des datasets annotés ou par apprentissage non supervisé (comme proposé par Härkönen et al. [9]).

Nous nous sommes intéressés à deux de ces approches : InterFaceGAN et par Analyse de Composante Principale.

InterFaceGAN : Le principe

L'idée derrière InterFaceGAN est d'identifier les hyperplans associés à des attributs pré-déterminés en entraînant un SVM sur des données annotées. La méthode mise en oeuvre par les auteurs est la suivante :

Les résultats obtenus par cette méthode sont très bons et les hyperplans obtenus permettent une modification des attributs de façon décorrélée. Le paragraphe suivant traite de l'utilisation des frontières d'InterfaceGAN pour la modification d'attributs d'images réelles.

3.1 Utilisation d'InterFaceGAN pour la manipulation sémantique d'images réelles

La manipulation d'attributs se base ici sur les frontières obtenues dans la plateforme interface GAN. Ici, la manipulation ne s'effectue que sur les couches [2,3,4,5] du modèle StyleGAN - 256x256 FFHQ. La partie sythèse du générateur Style GAN augmente incrémentalement la résolution de l'image, de 4x4 à 256x256. Le réseau comporte donc 14 couches -- 2 pour chaque résolution. Ceci peut-être vérifié en chargeant le code latent calculé précédement (pour une image réelle) et en évaluant sa taille.

Chargeons la valeur du code latent obtenu dans le cas 1 précédent (cf Paragraphe 3.2.1)

Cette section porte sur la manipulation d'attributs d'images réelles, en utilisant les frontières proposées dans InterfaceGAN.

Réalisons les réglages du modèle à utiliser.

Appliquons par la suite une boucle sur les frontières: age, expressions, lunettes, genre et pose.

Affichons les images obtenues. Les résultats sont sématiquement parlants, mais nous remarque tout de même la corrélation entre certains attributs (âge et lunettes, ou bien âge et genre). En revanche, les attributs pose et expression sont relativement bien représentés par les vecteurs normaux de l'espace latent chargés.

3.2 Analyse en Composantes Principales (PCA)

Les résultats obtenus par InterFaceGAN sont très bons, mais ceux-ci nécessitent l'annotation d'un dataset. La question dès lors est: peut-on reproduire ces résultats sans supervisation ?

L'idée de la méthode est la suivante : les directions de principales variances devrait être liées à des attributs spécifiques (des visages dans notre cas, e.g. le genre, l'âge, la pose de la personne). En effectuant une Analyse en Composantes Principales, on devrait obtenir une bonne approximation des hyperplans correspondant à chaque attributs. À noter que de cette manière, nous n'avons pas de garantie sur les attributs qui seront identifiés au préalable, mais nous ne nous limitons pas de même à un nombre fixe d'attributs identifiables.

La réalisation pratique de cette méthode est la suivante :

On peut ainsi identifier des composantes liés à certains attributs spécifiques (genre, âge, etc.). On observe que certains attributs sont liés à une même composantes. Pour les délier, on peut injecter la modification $Zx$ dans seulement quelques layers de StyleGAN 2. Cela menant à un contrôle fin de ces attributs.

Nous avons d'abord tenté d'implémenter une approche par PCA avec le même modèle pré-entraîné de StyleGAN 1 utilisé dans la partie précédente sur l'inversion d'une image réelle. Cependant ce modèle utilisé nous donne uniquement accès à l'espace $\mathcal{W}+$, car utiliser cet espace est plus intéressant dans le contexte d'une inversion d'image réelle car le gap vis-à-vis de la taille à l'image réelle est plus faible. Nous avons donc réalisé la PCA sur cet espace $\mathcal{W}+$ et nous observons que la manipulation des attributs bien qu'existante n'est pas aussi bonne que l'on pourrait s'y attendre. Nous avons donc implémenter cette approche en utilisant un modèle pré-entraîné de StyleGAN 2 nous donnant accès à l'espace latent $\mathcal{W}+$. Les résultats obtenus ont été bien meilleurs et comparables aux résultats obtenus par SVM avec l'approche d'InterFaceGAN.

Le tableau suivant résume les attributs que nous avons identifiés comme facilement manipulables pour StyleGAN 2 ainsi que les composantes auxquels ils sont liés et les layer sur lesquels ils agissent.

Attributs      | Composante | Layer d'injection
-----------------------------------------------
Genre          |      0     |        4-6
-----------------------------------------------
Age            |      3     |        3-7
-----------------------------------------------
Pose           |      1     |        0-2
-----------------------------------------------
Lunettes       |      3     |        1,2
-----------------------------------------------
Cheveux blancs |      16    |        7-9
-----------------------------------------------
Luminosité     |      2     |       10-17
Expériences avec StyleGAN 1
Expériences avec StyleGAN 2

Modification d'attributs spécifiques :

Conclusion : Exemple d'une pipeline complète

Cette étude de l'interprétation des StyleGANs a été réalisée en plusieurs étapes. Tout d'abord, un état de l'art sur les méthodes d'inversion du générateur des GANs a été réalisée. La méthode "hybride" In-Domain GAN Inversion a été étudiée, en particulier la sensibilité à l'initialisation du code latent dans $\mathcal{W}^{+}$. Le choix de $\mathcal{W}^{+}$ comme espace d'inversion a été motivé par la qualité de l'encodage pouvant être réalisé : un encodage $\mathbb{R}^{256 \times 256} \rightarrow \mathbb{R}^{14 \times 256}$ étant moins exigeant qu'un encodage $\mathbb{R}^{256 \times 256} \rightarrow \mathbb{R}^{256}$ . Enfin, cette inversion nous a permis d'agir sur l'image via la manipulation d'attributs, ces frontières étant précalculées dans InterfaceGAN. Par la suite, il a été choisi de mener une étude sur le calcul de frontières, en utilisant une PCA au lieu des SVMs utilisés dans interface GAN afin de s'affranchir des contraintes d'annotations des données inhérentes aux SVMs. L'inversion, réalisée dans $\mathcal{W}^{+}$ et non $\mathcal{W}$ a rendu la réalisation de la PCA plus délicate, et les frontières des attributs moins parlantes d'un point de vue sémantiques par rapport à celles obtenues dans $\mathcal{W}$.

Nous concluons en proposant d'une pipeline permettant d'inverser une image réelle, et d'agir sur un de ces attributs par PCA.